// 购物车模块

import { checkAllCart, deleteCart, findCartList, getNewCartGoods, insertCart, mergeLocalCart, updateCart } from "@/api/cart"

// 购物车状态
export default {
    namespaced: true,
    state: () => {
        return {
            list: []
        }
    },
    getters: {
        // 有效商品列表
        validList(state) {
            return state.list.filter(goods => goods.stock > 0 && goods.isEffective)
        },
        // 有效商品总数
        validTotal(state, getters) {
            return getters.validList.reduce((p, c) => p += c.count, 0)
        },
        // 有效商品总金额
        validAmount(state, getters) {
            // return getters.validList.reduce((p, c) => p += c.count * c.nowPrice * 100, 0) / 100
            return getters.validList.reduce((p, c) => p + c.count * Math.round(c.nowPrice) * 100, 0) / 100
        },
        // 失效商品数据
        invalidList(state) {
            return state.list.filter(goods => !(goods.stock > 0 && goods.isEffective))
        },
        // 已选择商品数据
        selectedList(state, getters) {
            return getters.validList.filter(goods => goods.selected)
        },
        // 选中商品件数
        selectedTotal(state, getters) {
            return getters.selectedList.reduce((p, c) => p + c.count, 0)
        },
        // 选中商品总金额
        selectedAmount(state, getters) {
            return getters.selectedList.reduce((p, c) => p + Math.round(c.count * c.nowPrice) * 100, 0) / 100
        },
        // 是否全选
        isAll(state, getters) {
            return getters.validList.length === getters.selectedList.length && getters.selectedList.length > 0
        }
    },
    // 本地：id skuId name picture price nowPrice count attrsText selected stock isEffective
    // 线上：比上面多 isCollect 有用 discount 无用 两项项信息
    mutations: {
        // 添加购物车
        insertCart(state, goods) {
            const sameIndex = state.list.findIndex(good => good.skuId === goods.skuId)
            // 逻辑：有相同的给goods累加数量，删除相同skuId的商品
            if (sameIndex >= 0) {
                goods.count += state.list[sameIndex].count;
                state.list.splice(sameIndex, 1);
            }
            state.list.unshift(goods);
        },
        // 修改购物车商品
        updateCart(state, goods) {
            // goods中字段有可能不完整，goods有的信息才去修改。
            // 1. goods中必需有skuId，才能找到对应的商品信息
            const updateGoods = state.list.find((item) =>
                item.skuId === goods.skuId
            )
            for (const key in goods) {
                if (goods[key] !== null && goods[key] !== undefined && goods[key] !== '') {
                    updateGoods[key] = goods[key];
                }
            }
        },
        // 删除本地购物车商品
        deleteCart(state, skuId) {
            const index = state.list.findIndex((item) => item.skuId === skuId);
            state.list.splice(index, 1);
        },
        // 设置购物车列表
        setCartList(state, list) {
            state.list = list
        }
    },
    actions: {
        // 合并本地购物车
        async mergeLocalCart(ctx) {
            // 存储token后调用合并API接口函数进行购物合并
            const cartList = ctx.getters.validList.map(
                ({ skuId, selected, count }) => {
                    return { skuId, selected, count }
                })
            await mergeLocalCart(cartList);
            // 合并成功将本地购物车删除
            ctx.commit('setCartList', [])
        },
        // 修改购物车商品
        updateCart(ctx, goods) {
            return new Promise((resolve, reject) => {
                if (ctx.rootState.user.profile.token) {
                    // 登录
                    updateCart(goods).then(() => {
                        return findCartList();
                    }).then(data => {
                        ctx.commit('setCartList', data.result);
                        resolve();
                    })
                } else {
                    ctx.commit('updateCart', goods)
                    resolve();
                }
            })
        },
        //加入购物车
        insertCart(ctx, goods) {
            return new Promise((resolve, reject) => {
                if (ctx.rootState.user.profile.token) {
                    // 登录
                    insertCart(goods).then(() => {
                        return findCartList();
                    }).then((data) => {
                        ctx.commit('setCartList', data.result);
                        resolve();
                    })
                } else {
                    // 本地
                    ctx.commit('insertCart', goods)
                    resolve();
                }
            })
        },
        // 获取购物车列表
        findCartList(ctx) {
            return new Promise((resolve, reject) => {
                if (ctx.rootState.user.profile.token) {
                    // 登录
                    findCartList().then((data) => {
                        ctx.commit('setCartList', data.result);
                        resolve();
                    })

                } else {
                    // 本地
                    // Promise.all() 可以并列发送多个请求，等所有请求成功，调用then
                    // Promise.race() 可以并列发送多个请求，等最快的请求成功，调用then
                    // 传参事promise数组
                    const promiseArr = ctx.state.list.map(item => {
                        // 返回接口函数的调用
                        return getNewCartGoods(item.skuId)
                    })
                    Promise.all(promiseArr).then(dataList => {
                        dataList.forEach((data, i) => {
                            ctx.commit('updateCart', { skuId: ctx.state.list[i].skuId, ...data.result })
                        })
                        resolve();
                    }).catch((err) => {
                        reject(err);
                    })
                }
            })
        },
        // 删除购物车商品
        deleteCart(ctx, skuId) {
            return new Promise((resolve, reject) => {
                if (ctx.rootState.user.profile.token) {
                    // 登录
                    deleteCart([skuId]).then(() => {
                        return findCartList();
                    }).then((data) => {
                        ctx.commit('setCartList', data.result);
                        resolve();
                    })
                } else {
                    ctx.commit('deleteCart', skuId)
                    resolve();
                }
            })
        },
        // 批量删除数据
        batchDeleteCart(ctx, isClear) {
            return new Promise((resolve, reject) => {
                if (ctx.rootState.user.profile.token) {
                    // 登录
                    const ids = ctx.getters[isClear ? 'invalidList' : 'selectedList'].map(item => item.skuId)
                    deleteCart(ids).then(() => {
                        return findCartList();
                    }).then((data) => {
                        ctx.commit('setCartList', data.result);
                        resolve();
                    })
                } else {

                    ctx.getters[isClear ? 'invalidList' : 'selectedList'].forEach((item) => {
                        ctx.commit('deleteCart', item.skuId)
                    })
                    resolve();
                }
            })
        },
        // 做有效商品的全选&反选
        checkAllCart(ctx, selected) {
            return new Promise((resolve, reject) => {
                if (ctx.rootState.user.profile.token) {
                    // 登录
                    const ids = ctx.getters.validList.map(item => item.skuId);
                    checkAllCart({ selected, ids }).then(() => {
                        return findCartList();
                    }).then(data => {
                        ctx.commit('setCartList', data.result);
                        resolve();
                    })
                } else {
                    // 本地
                    // 1. 获取有效的商品列表，遍历的去调用修改mutations即可
                    ctx.getters.validList.forEach(item => {
                        ctx.commit('updateCart', { skuId: item.skuId, selected })
                    })
                    resolve();
                }
            })
        },
        // 修改商品规格
        updateCartSku(ctx, { oldSkuId, newSku }) {
            return new Promise((resolve, reject) => {
                if (ctx.rootState.user.profile.token) {
                    // 登录
                    // 但你修改了sku的时候其实skuId需要更改，相当于把原来的信息移出，创建一条新的商品信息。
                    // 1. 获取旧的商品信息
                    const oldGoods = ctx.state.list.find(item => item.skuId === oldSkuId)
                    // 2. 删除旧的商品
                    deleteCart([oldSkuId])
                        .then(() => {
                            // 3. 插入最新商品规格数据
                            return insertCart({ skuId: newSku.skuId, count: oldGoods.count });
                        }).then(() => {
                            // 4. 请求最新数据
                            return findCartList();
                        }).then(data => {
                            // 5. 更改数据
                            ctx.commit('setCartList', data.result)
                            resolve()
                        })
                } else {
                    // 本地
                    // 但你修改了sku的时候其实skuId需要更改，相当于把原来的信息移出，创建一条新的商品信息。
                    // 1. 获取旧的商品信息
                    const oldGoods = ctx.state.list.find(item => item.skuId === oldSkuId)
                    // 2. 删除旧的商品
                    ctx.commit('deleteCart', oldSkuId);
                    // 3. 合并一条新的商品信息
                    const { skuId, price: nowPrice, inventory: stock, specsText: attrsText } = newSku;
                    const newGoods = { ...oldGoods, skuId, nowPrice, stock, attrsText }
                    // 4. 插入最新商品规格数据
                    ctx.commit('insertCart', newGoods);
                }
            })
        }
    }
}
